#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include<algorithm>
using namespace std;
struct Num{
	long long num;
	int times;
};
Num num[200005];
struct Rule3{
	bool operator()(const Num &a1,const Num &a2){
		return a1.num<a2.num;
	}
};
/*
double f(double a,double b,double c,double d,double x){
	return a*x*x*x+b*x*x+c*x+d;
}
*/
/*
long long sum=0;
void merge2(int a[],int low,int mid,int high){
	int lenb=mid-low+1;
	int b[lenb];
	for(int i=0;i<lenb;i++){
		b[i]=a[low+i];
	}
	int lenc=high-mid;
	int c[lenc];
	for(int i=0;i<lenc;i++){
		c[i]=a[mid+1+i];
	}
	
	int i=0,j=0,index=low;
	while(i<lenb&&j<lenc){
		if(b[i]<=c[j]){
			a[index++]=b[i++];
		}else{
			sum+=lenb-i;
			a[index++]=c[j++];
		}
	}
	while(i<lenb){
		a[index++]=b[i++];
	}
	while(j<lenc){
		a[index++]=c[j++];
	}
}
void mergeSort(int a[],int low,int high){
	if(low<high){
		int mid=(high+low)/2;
		mergeSort(a,low,mid);
		mergeSort(a,mid+1,high);
		merge2(a,low,mid,high);
	}
}
*/
/*
struct Node{
	int left,right;
};
struct Rule2{
	bool operator()(const Node &a1,const Node &a2){
		return a1.left<a2.left;
	}
};
struct Rule1{
	bool operator()(const long long &a1,const long long &a2){
		return a1>a2;
	}
};
const int maxn = 1000;
 
struct bign{
    int d[maxn], len;
 
	void clean() { while(len > 1 && !d[len-1]) len--; }
 
    bign() 			{ memset(d, 0, sizeof(d)); len = 1; }
    bign(int num) 	{ *this = num; } 
	bign(char* num) { *this = num; }
    bign operator = (const char* num){
        memset(d, 0, sizeof(d)); len = strlen(num);
        for(int i = 0; i < len; i++) d[i] = num[len-1-i] - '0';
        clean();
		return *this;
    }
    bign operator = (int num){
        char s[maxn]; sprintf(s, "%d", num);
        *this = s;
		return *this;
    }
 
    bign operator + (const bign& b){
        bign c = *this; int i;
        for (i = 0; i < b.len; i++){
        	c.d[i] += b.d[i];
        	if (c.d[i] > 9) c.d[i]%=10, c.d[i+1]++;
		}
		while (c.d[i] > 9) c.d[i++]%=10, c.d[i]++;
		c.len = max(len, b.len);
		if (c.d[i] && c.len <= i) c.len = i+1;
        return c;
    }
    bign operator - (const bign& b){
        bign c = *this; int i;
        for (i = 0; i < b.len; i++){
        	c.d[i] -= b.d[i];
        	if (c.d[i] < 0) c.d[i]+=10, c.d[i+1]--;
		}
		while (c.d[i] < 0) c.d[i++]+=10, c.d[i]--;
		c.clean();
		return c;
    }
    bign operator * (const bign& b)const{
        int i, j; bign c; c.len = len + b.len; 
        for(j = 0; j < b.len; j++) for(i = 0; i < len; i++) 
			c.d[i+j] += d[i] * b.d[j];
        for(i = 0; i < c.len-1; i++)
            c.d[i+1] += c.d[i]/10, c.d[i] %= 10;
        c.clean();
		return c;
    }
    bign operator / (const bign& b){
    	int i, j;
		bign c = *this, a = 0;
    	for (i = len - 1; i >= 0; i--)
    	{
    		a = a*10 + d[i];
    		for (j = 0; j < 10; j++) if (a < b*(j+1)) break;
    		c.d[i] = j;
    		a = a - b*j;
    	}
    	c.clean();
    	return c;
    }
    bign operator % (const bign& b){
    	int i, j;
		bign a = 0;
    	for (i = len - 1; i >= 0; i--)
    	{
    		a = a*10 + d[i];
    		for (j = 0; j < 10; j++) if (a < b*(j+1)) break;
    		a = a - b*j;
    	}
    	return a;
    }
	bign operator += (const bign& b){
        *this = *this + b;
        return *this;
    }
 
    bool operator <(const bign& b) const{
        if(len != b.len) return len < b.len;
        for(int i = len-1; i >= 0; i--)
            if(d[i] != b.d[i]) return d[i] < b.d[i];
        return false;
    }
    bool operator >(const bign& b) const{return b < *this;}
    bool operator<=(const bign& b) const{return !(b < *this);}
    bool operator>=(const bign& b) const{return !(*this < b);}
    bool operator!=(const bign& b) const{return b < *this || *this < b;}
    bool operator==(const bign& b) const{return !(b < *this) && !(b > *this);}
 
    string str() const{
        char s[maxn]={};
        for(int i = 0; i < len; i++) s[len-1-i] = d[i]+'0';
        return s;
    }
};
 
istream& operator >> (istream& in, bign& x)
{
    string s;
    in >> s;
    x = s.c_str();
    return in;
}
 
ostream& operator << (ostream& out, const bign& x)
{
    out << x.str();
    return out;
}
*/
/*
bign a[255];
void count(){
	a[0]=1;
	a[1]=1;
	a[2]=3;
	
	for(int i=3;i<=250;i++){
		a[i]=a[i-1]+a[i-2]*2;
	}
	
}
*/
/*
bign _2011(int n){
	if(n==0){
		bign res=1;
		return res;
	}
	else if(n==1) {
		bign res=2011;
		return res;
	}else {
		bign temp1=10000;
		bign temp2=2011;
		bign a=_2011(n/2);
		if (n%2==0){
			bign res;
			res=a*a%temp1;
			return res;
		} else{
			bign res;
			res=a*a%temp1;
			res=res*temp2%temp1;
			return res;
		} 
	}
}
*/
int main(){
	/*
	int x;
	count();
	while(cin>>x){		
		cout<<a[x]<<endl;
	}
	*/
	
	
	//10:閿熸枻鎷烽敓鏂ゆ嫹閿熸枻鎷烽敓鎺ュ嚖鎷�
	/*
	bign a,b,sum;
	cin>>a>>b;
	sum=a+b;
	cout<<sum; 
	*/
	
	
	//15:閿熼樁涔樼尨鎷�
	/*
	int N;
	cin>>N;
	bign ans[N+5];
	ans[1]=1;
	ans[2]=2;
	for(int  i=3;i<=N;i++){
		bign temp=i;
		ans[i]=temp*ans[i-1];
	} 
	bign sum=0;
	for(int i=1;i<=N;i++){
		sum=sum+ans[i];
	}
	
	cout<<sum;
	*/
	
	//47:閿熸枻鎷烽敓鏂ゆ嫹閿熸枻鎷烽敓鏂ゆ嫹閿熸枻鎷�
	//09:閿熸枻鎷烽敓鏂ゆ嫹閿熸枻鎷烽敓鍓垮嚖鎷�
	/*
	bign a,b,ans;
	cin>>a>>b;
//	ans=a/b;
	ans=a*b;
	cout<<ans;
	*/
	
	//2991:2011
	/*
	int n;
	cin>>n;
	while(n--){
		int x;
		cin>>x;
		
		cout<<_2011(x)<<endl;
	}
	*/
	
	//7617:閿熸枻鎷烽敓瑙掔櫤閿熸枻鎷烽敓鏂ゆ嫹閿燂拷
	/*
	int n;
	cin>>n;
	long long a[n+5];
	for(int i=0;i<n;i++){
		cin>>a[i];
	}
	int k;
	cin>>k;
	sort(a,a+n,Rule1());
	for(int i=0;i<k;i++)
	cout<<a[i]<<endl;
	*/
	
	//7620:閿熸枻鎷烽敓鏂ゆ嫹鍠滈敓锟�
	/*
	int n;
	cin>>n;
	Node node[n+5];
	for(int i=0;i<n;i++){
		cin>>node[i].left>>node[i].right;
	}
	sort(node,node+n,Rule2());
	Node total;
	total=node[0];
	for(int i=1;i<n;i++){
		if(node[i].left<=total.right){
			total.right=node[i].right>total.right?node[i].right:total.right;
		}else{
			cout<<"no";
			return 0;
		}
	} 
	cout<<total.left<<' '<<total.right;
	*/
	
	
	//7622:閿熸枻鎷烽敓鏂ゆ嫹閿熷彨纰夋嫹閿熸枻鎷烽敓鏂ゆ嫹閿熸枻鎷�
	/*
	int n;
	cin>>n;
	int a[n];
	for(int i=0;i<n;i++){
		cin>>a[i];
	}
	mergeSort(a,0,n-1);
	cout<<sum;
	*/
	
	//7891:涓€鍏冮敓鏂ゆ嫹閿熻娇鍑ゆ嫹閿熸枻鎷烽敓鏂ゆ嫹閿燂拷
	/*
	double a,b,c,d,x;
	scanf("%lf %lf %lf %lf %lf",&a,&b,&c,&d,&x);
	*/
	
	
	//7909:缁熼敓鏂ゆ嫹閿熸枻鎷烽敓鏂ゆ嫹
	/*
	int n;
	cin>>n;
	
	int i;
	for(i=0;i<n;i++){
		cin>>num[i].num;
		num[i].times=1;
	}
	sort(num,num+n,Rule3());
	
	for(int i=0;i<n;i++){
		if(num[i].num==num[i+1].num){
			num[i+1].times+=num[i].times;
		}else{
			cout<<num[i].num<<' '<<num[i].times<<endl;
		}
	}
	*/

	return 0;
}
